﻿//Copyright (c) 2010 Christopher E. S. King (http://chriskingconsulting.com)
//
//Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files 
// (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, 
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do 
// so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE 
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Collections;
using System.Collections.Concurrent;
using System.Threading;
using System.Runtime.Remoting;
using System.Threading.Tasks;
using System.Diagnostics.Contracts;
using System.Reflection;
using System.Diagnostics;
using Roslyn.Compilers.CSharp;
using System.Text.RegularExpressions;

using King.Declarative;
using King.Text;
using King.Reflection;
using King.Extensions;
using King.Collections;
using King.Traverse;
using King.CSharp.Reflection;

namespace King.CSharp.Text {

    #region Keywords
    [CSharpSymbol(SyntaxKind.BoolKeyword)]
    public sealed class CSharpBoolKeyword : CSharpKeywordToken {
        public CSharpBoolKeyword() { }
        internal CSharpBoolKeyword(SyntaxToken token) : base(token) { }
        internal CSharpBoolKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ByteKeyword)]
    public sealed class CSharpByteKeyword : CSharpKeywordToken {
        public CSharpByteKeyword() { }
        internal CSharpByteKeyword(SyntaxToken token) : base(token) { }
        internal CSharpByteKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.SByteKeyword)]
    public sealed class CSharpSByteKeyword : CSharpKeywordToken {
        public CSharpSByteKeyword() { }
        internal CSharpSByteKeyword(SyntaxToken token) : base(token) { }
        internal CSharpSByteKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ShortKeyword)]
    public sealed class CSharpShortKeyword : CSharpKeywordToken {
        public CSharpShortKeyword() { }
        internal CSharpShortKeyword(SyntaxToken token) : base(token) { }
        internal CSharpShortKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.UShortKeyword)]
    public sealed class CSharpUShortKeyword : CSharpKeywordToken {
        public CSharpUShortKeyword() { }
        internal CSharpUShortKeyword(SyntaxToken token) : base(token) { }
        internal CSharpUShortKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.IntKeyword)]
    public sealed class CSharpIntKeyword : CSharpKeywordToken {
        public CSharpIntKeyword() { }
        internal CSharpIntKeyword(SyntaxToken token) : base(token) { }
        internal CSharpIntKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.UIntKeyword)]
    public sealed class CSharpUIntKeyword : CSharpKeywordToken {
        public CSharpUIntKeyword() { }
        internal CSharpUIntKeyword(SyntaxToken token) : base(token) { }
        internal CSharpUIntKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.LongKeyword)]
    public sealed class CSharpLongKeyword : CSharpKeywordToken {
        public CSharpLongKeyword() { }
        internal CSharpLongKeyword(SyntaxToken token) : base(token) { }
        internal CSharpLongKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ULongKeyword)]
    public sealed class CSharpULongKeyword : CSharpKeywordToken {
        public CSharpULongKeyword() { }
        internal CSharpULongKeyword(SyntaxToken token) : base(token) { }
        internal CSharpULongKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.DoubleKeyword)]
    public sealed class CSharpDoubleKeyword : CSharpKeywordToken {
        public CSharpDoubleKeyword() { }
        internal CSharpDoubleKeyword(SyntaxToken token) : base(token) { }
        internal CSharpDoubleKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.FloatKeyword)]
    public sealed class CSharpFloatKeyword : CSharpKeywordToken {
        public CSharpFloatKeyword() { }
        internal CSharpFloatKeyword(SyntaxToken token) : base(token) { }
        internal CSharpFloatKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.DecimalKeyword)]
    public sealed class CSharpDecimalKeyword : CSharpKeywordToken {
        public CSharpDecimalKeyword() { }
        internal CSharpDecimalKeyword(SyntaxToken token) : base(token) { }
        internal CSharpDecimalKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.StringKeyword)]
    public sealed class CSharpStringKeyword : CSharpKeywordToken {
        public CSharpStringKeyword() { }
        internal CSharpStringKeyword(SyntaxToken token) : base(token) { }
        internal CSharpStringKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.CharKeyword)]
    public sealed class CSharpCharKeyword : CSharpKeywordToken {
        public CSharpCharKeyword() { }
        internal CSharpCharKeyword(SyntaxToken token) : base(token) { }
        internal CSharpCharKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.VoidKeyword)]
    public sealed class CSharpVoidKeyword : CSharpKeywordToken {
        public CSharpVoidKeyword() { }
        internal CSharpVoidKeyword(SyntaxToken token) : base(token) { }
        internal CSharpVoidKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ObjectKeyword)]
    public sealed class CSharpObjectKeyword : CSharpKeywordToken {
        public CSharpObjectKeyword() { }
        internal CSharpObjectKeyword(SyntaxToken token) : base(token) { }
        internal CSharpObjectKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.NullKeyword)]
    public sealed class CSharpNullKeyword : CSharpKeywordToken {
        public CSharpNullKeyword() { }
        internal CSharpNullKeyword(SyntaxToken token) : base(token) { }
        internal CSharpNullKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // literals
    [CSharpSymbol(SyntaxKind.TrueKeyword)]
    public sealed class CSharpTrueKeyword : CSharpKeywordToken {
        public CSharpTrueKeyword() { }
        internal CSharpTrueKeyword(SyntaxToken token) : base(token) { }
        internal CSharpTrueKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.FalseKeyword)]
    public sealed class CSharpFalseKeyword : CSharpKeywordToken {
        public CSharpFalseKeyword() { }
        internal CSharpFalseKeyword(SyntaxToken token) : base(token) { }
        internal CSharpFalseKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // control flow
    [CSharpSymbol(SyntaxKind.IfKeyword)]
    public sealed class CSharpIfKeyword : CSharpKeywordToken {
        public CSharpIfKeyword() { }
        internal CSharpIfKeyword(SyntaxToken token) : base(token) { }
        internal CSharpIfKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ElseKeyword)]
    public sealed class CSharpElseKeyword : CSharpKeywordToken {
        public CSharpElseKeyword() { }
        internal CSharpElseKeyword(SyntaxToken token) : base(token) { }
        internal CSharpElseKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.WhileKeyword)]
    public sealed class CSharpWhileKeyword : CSharpKeywordToken {
        public CSharpWhileKeyword() { }
        internal CSharpWhileKeyword(SyntaxToken token) : base(token) { }
        internal CSharpWhileKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ForKeyword)]
    public sealed class CSharpForKeyword : CSharpKeywordToken {
        public CSharpForKeyword() { }
        internal CSharpForKeyword(SyntaxToken token) : base(token) { }
        internal CSharpForKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ForEachKeyword)]
    public sealed class CSharpForEachKeyword : CSharpKeywordToken {
        public CSharpForEachKeyword() { }
        internal CSharpForEachKeyword(SyntaxToken token) : base(token) { }
        internal CSharpForEachKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.DoKeyword)]
    public sealed class CSharpDoKeyword : CSharpKeywordToken {
        public CSharpDoKeyword() { }
        internal CSharpDoKeyword(SyntaxToken token) : base(token) { }
        internal CSharpDoKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.BreakKeyword)]
    public sealed class CSharpBreakKeyword : CSharpKeywordToken {
        public CSharpBreakKeyword() { }
        internal CSharpBreakKeyword(SyntaxToken token) : base(token) { }
        internal CSharpBreakKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ContinueKeyword)]
    public sealed class CSharpContinueKeyword : CSharpKeywordToken {
        public CSharpContinueKeyword() { }
        internal CSharpContinueKeyword(SyntaxToken token) : base(token) { }
        internal CSharpContinueKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // switch
    [CSharpSymbol(SyntaxKind.SwitchKeyword)]
    public sealed class CSharpSwitchKeyword : CSharpKeywordToken {
        public CSharpSwitchKeyword() { }
        internal CSharpSwitchKeyword(SyntaxToken token) : base(token) { }
        internal CSharpSwitchKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.CaseKeyword)]
    public sealed class CSharpCaseKeyword : CSharpKeywordToken {
        public CSharpCaseKeyword() { }
        internal CSharpCaseKeyword(SyntaxToken token) : base(token) { }
        internal CSharpCaseKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.DefaultKeyword)]
    public sealed class CSharpDefaultKeyword : CSharpKeywordToken {
        public CSharpDefaultKeyword() { }
        internal CSharpDefaultKeyword(SyntaxToken token) : base(token) { }
        internal CSharpDefaultKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // jumps
    [CSharpSymbol(SyntaxKind.GotoKeyword)]
    public sealed class CSharpGotoKeyword : CSharpKeywordToken {
        public CSharpGotoKeyword() { }
        internal CSharpGotoKeyword(SyntaxToken token) : base(token) { }
        internal CSharpGotoKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ReturnKeyword)]
    public sealed class CSharpReturnKeyword : CSharpKeywordToken {
        public CSharpReturnKeyword() { }
        internal CSharpReturnKeyword(SyntaxToken token) : base(token) { }
        internal CSharpReturnKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.YieldKeyword)]
    public sealed class CSharpYieldKeyword : CSharpKeywordToken {
        public CSharpYieldKeyword() { }
        internal CSharpYieldKeyword(SyntaxToken token) : base(token) { }
        internal CSharpYieldKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // exceptions
    [CSharpSymbol(SyntaxKind.ThrowKeyword)]
    public sealed class CSharpThrowKeyword : CSharpKeywordToken {
        public CSharpThrowKeyword() { }
        internal CSharpThrowKeyword(SyntaxToken token) : base(token) { }
        internal CSharpThrowKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.TryKeyword)]
    public sealed class CSharpTryKeyword : CSharpKeywordToken {
        public CSharpTryKeyword() { }
        internal CSharpTryKeyword(SyntaxToken token) : base(token) { }
        internal CSharpTryKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.CatchKeyword)]
    public sealed class CSharpCatchKeyword : CSharpKeywordToken {
        public CSharpCatchKeyword() { }
        internal CSharpCatchKeyword(SyntaxToken token) : base(token) { }
        internal CSharpCatchKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.FinallyKeyword)]
    public sealed class CSharpFinallyKeyword : CSharpKeywordToken {
        public CSharpFinallyKeyword() { }
        internal CSharpFinallyKeyword(SyntaxToken token) : base(token) { }
        internal CSharpFinallyKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // visibility
    [CSharpSymbol(SyntaxKind.PublicKeyword)]
    public sealed class CSharpPublicKeyword : CSharpKeywordToken {
        public CSharpPublicKeyword() { }
        internal CSharpPublicKeyword(SyntaxToken token) : base(token) { }
        internal CSharpPublicKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.PrivateKeyword)]
    public sealed class CSharpPrivateKeyword : CSharpKeywordToken {
        public CSharpPrivateKeyword() { }
        internal CSharpPrivateKeyword(SyntaxToken token) : base(token) { }
        internal CSharpPrivateKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.InternalKeyword)]
    public sealed class CSharpInternalKeyword : CSharpKeywordToken {
        public CSharpInternalKeyword() { }
        internal CSharpInternalKeyword(SyntaxToken token) : base(token) { }
        internal CSharpInternalKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ProtectedKeyword)]
    public sealed class CSharpProtectedKeyword : CSharpKeywordToken {
        public CSharpProtectedKeyword() { }
        internal CSharpProtectedKeyword(SyntaxToken token) : base(token) { }
        internal CSharpProtectedKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // modifiers
    [CSharpSymbol(SyntaxKind.StaticKeyword)]
    public sealed class CSharpStaticKeyword : CSharpKeywordToken {
        public CSharpStaticKeyword() { }
        internal CSharpStaticKeyword(SyntaxToken token) : base(token) { }
        internal CSharpStaticKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ReadOnlyKeyword)]
    public sealed class CSharpReadOnlyKeyword : CSharpKeywordToken {
        public CSharpReadOnlyKeyword() { }
        internal CSharpReadOnlyKeyword(SyntaxToken token) : base(token) { }
        internal CSharpReadOnlyKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.SealedKeyword)]
    public sealed class CSharpSealedKeyword : CSharpKeywordToken {
        public CSharpSealedKeyword() { }
        internal CSharpSealedKeyword(SyntaxToken token) : base(token) { }
        internal CSharpSealedKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ConstKeyword)]
    public sealed class CSharpConstKeyword : CSharpKeywordToken {
        public CSharpConstKeyword() { }
        internal CSharpConstKeyword(SyntaxToken token) : base(token) { }
        internal CSharpConstKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.FixedKeyword)]
    public sealed class CSharpFixedKeyword : CSharpKeywordToken {
        public CSharpFixedKeyword() { }
        internal CSharpFixedKeyword(SyntaxToken token) : base(token) { }
        internal CSharpFixedKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.StackAllocKeyword)]
    public sealed class CSharpStackAllocKeyword : CSharpKeywordToken {
        public CSharpStackAllocKeyword() { }
        internal CSharpStackAllocKeyword(SyntaxToken token) : base(token) { }
        internal CSharpStackAllocKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.UnsafeKeyword)]
    public sealed class CSharpUnsafeKeyword : CSharpKeywordToken {
        public CSharpUnsafeKeyword() { }
        internal CSharpUnsafeKeyword(SyntaxToken token) : base(token) { }
        internal CSharpUnsafeKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.PartialKeyword)]
    public sealed class CSharpPartialKeyword : CSharpKeywordToken {
        public CSharpPartialKeyword() { }
        internal CSharpPartialKeyword(SyntaxToken token) : base(token) { }
        internal CSharpPartialKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ExternKeyword)]
    public sealed class CSharpExternKeyword : CSharpKeywordToken {
        public CSharpExternKeyword() { }
        internal CSharpExternKeyword(SyntaxToken token) : base(token) { }
        internal CSharpExternKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.NewKeyword)]
    public sealed class CSharpNewKeyword : CSharpKeywordToken {
        public CSharpNewKeyword() { }
        internal CSharpNewKeyword(SyntaxToken token) : base(token) { }
        internal CSharpNewKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.OverrideKeyword)]
    public sealed class CSharpOverrideKeyword : CSharpKeywordToken {
        public CSharpOverrideKeyword() { }
        internal CSharpOverrideKeyword(SyntaxToken token) : base(token) { }
        internal CSharpOverrideKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.AbstractKeyword)]
    public sealed class CSharpAbstractKeyword : CSharpKeywordToken {
        public CSharpAbstractKeyword() { }
        internal CSharpAbstractKeyword(SyntaxToken token) : base(token) { }
        internal CSharpAbstractKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.VirtualKeyword)]
    public sealed class CSharpVirtualKeyword : CSharpKeywordToken {
        public CSharpVirtualKeyword() { }
        internal CSharpVirtualKeyword(SyntaxToken token) : base(token) { }
        internal CSharpVirtualKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // type checking
    [CSharpSymbol(SyntaxKind.IsKeyword)]
    public sealed class CSharpIsKeyword : CSharpKeywordToken {
        public CSharpIsKeyword() { }
        internal CSharpIsKeyword(SyntaxToken token) : base(token) { }
        internal CSharpIsKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.AsKeyword)]
    public sealed class CSharpAsKeyword : CSharpKeywordToken {
        public CSharpAsKeyword() { }
        internal CSharpAsKeyword(SyntaxToken token) : base(token) { }
        internal CSharpAsKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.TypeOfKeyword)]
    public sealed class CSharpTypeOfKeyword : CSharpKeywordToken {
        public CSharpTypeOfKeyword() { }
        internal CSharpTypeOfKeyword(SyntaxToken token) : base(token) { }
        internal CSharpTypeOfKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.SizeOfKeyword)]
    public sealed class CSharpSizeOfKeyword : CSharpKeywordToken {
        public CSharpSizeOfKeyword() { }
        internal CSharpSizeOfKeyword(SyntaxToken token) : base(token) { }
        internal CSharpSizeOfKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // parameter modifiers
    [CSharpSymbol(SyntaxKind.RefKeyword)]
    public sealed class CSharpRefKeyword : CSharpKeywordToken {
        public CSharpRefKeyword() { }
        internal CSharpRefKeyword(SyntaxToken token) : base(token) { }
        internal CSharpRefKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.OutKeyword)]
    public sealed class CSharpOutKeyword : CSharpKeywordToken {
        public CSharpOutKeyword() { }
        internal CSharpOutKeyword(SyntaxToken token) : base(token) { }
        internal CSharpOutKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.InKeyword)]
    public sealed class CSharpInKeyword : CSharpKeywordToken {
        public CSharpInKeyword() { }
        internal CSharpInKeyword(SyntaxToken token) : base(token) { }
        internal CSharpInKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ParamsKeyword)]
    public sealed class CSharpParamsKeyword : CSharpKeywordToken {
        public CSharpParamsKeyword() { }
        internal CSharpParamsKeyword(SyntaxToken token) : base(token) { }
        internal CSharpParamsKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // variables
    [CSharpSymbol(SyntaxKind.ArgListKeyword)]
    public sealed class CSharpArgListKeyword : CSharpKeywordToken {
        public CSharpArgListKeyword() { }
        internal CSharpArgListKeyword(SyntaxToken token) : base(token) { }
        internal CSharpArgListKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.LockKeyword)]
    public sealed class CSharpLockKeyword : CSharpKeywordToken {
        public CSharpLockKeyword() { }
        internal CSharpLockKeyword(SyntaxToken token) : base(token) { }
        internal CSharpLockKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.TypeVarKeyword)]
    public sealed class CSharpVarKeyword : CSharpKeywordToken {
        public CSharpVarKeyword() { }
        internal CSharpVarKeyword(SyntaxToken token) : base(token) { }
        internal CSharpVarKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    //[CSharpSymbol(SyntaxKind.DynamicKeyword)]
    //public sealed class CSharpDynamicKeyword : CSharpKeywordToken {
    //    public CSharpDynamicKeyword() { }
    //    internal CSharpDynamicKeyword(SyntaxToken token) : base(token) { }
    //    internal CSharpDynamicKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    //}
    [CSharpSymbol(SyntaxKind.CheckedKeyword)]
    public sealed class CSharpCheckedKeyword : CSharpKeywordToken {
        public CSharpCheckedKeyword() { }
        internal CSharpCheckedKeyword(SyntaxToken token) : base(token) { }
        internal CSharpCheckedKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.UncheckedKeyword)]
    public sealed class CSharpUncheckedKeyword : CSharpKeywordToken {
        public CSharpUncheckedKeyword() { }
        internal CSharpUncheckedKeyword(SyntaxToken token) : base(token) { }
        internal CSharpUncheckedKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // esoteric
    [CSharpSymbol(SyntaxKind.MakeRefKeyword)]
    public sealed class CSharpMakeRefKeyword : CSharpKeywordToken {
        public CSharpMakeRefKeyword() { }
        internal CSharpMakeRefKeyword(SyntaxToken token) : base(token) { }
        internal CSharpMakeRefKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.RefTypeKeyword)]
    public sealed class CSharpRefTypeKeyword : CSharpKeywordToken {
        public CSharpRefTypeKeyword() { }
        internal CSharpRefTypeKeyword(SyntaxToken token) : base(token) { }
        internal CSharpRefTypeKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.RefValueKeyword)]
    public sealed class CSharpRefValueKeyword : CSharpKeywordToken {
        public CSharpRefValueKeyword() { }
        internal CSharpRefValueKeyword(SyntaxToken token) : base(token) { }
        internal CSharpRefValueKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.VolatileKeyword)]
    public sealed class CSharpVolatileKeyword : CSharpKeywordToken {
        public CSharpVolatileKeyword() { }
        internal CSharpVolatileKeyword(SyntaxToken token) : base(token) { }
        internal CSharpVolatileKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.AliasKeyword)]
    public sealed class CSharpAliasKeyword : CSharpKeywordToken {
        public CSharpAliasKeyword() { }
        internal CSharpAliasKeyword(SyntaxToken token) : base(token) { }
        internal CSharpAliasKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.GlobalKeyword)]
    public sealed class CSharpGlobalKeyword : CSharpKeywordToken {
        public CSharpGlobalKeyword() { }
        internal CSharpGlobalKeyword(SyntaxToken token) : base(token) { }
        internal CSharpGlobalKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.TypeVarKeyword)]
    public sealed class CSharpTypeVarKeyword : CSharpKeywordToken {
        public CSharpTypeVarKeyword() { }
        internal CSharpTypeVarKeyword(SyntaxToken token) : base(token) { }
        internal CSharpTypeVarKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // activation
    [CSharpSymbol(SyntaxKind.ThisKeyword)]
    public sealed class CSharpThisKeyword : CSharpKeywordToken {
        public CSharpThisKeyword() { }
        internal CSharpThisKeyword(SyntaxToken token) : base(token) { }
        internal CSharpThisKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.BaseKeyword)]
    public sealed class CSharpBaseKeyword : CSharpKeywordToken {
        public CSharpBaseKeyword() { }
        internal CSharpBaseKeyword(SyntaxToken token) : base(token) { }
        internal CSharpBaseKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // scope
    [CSharpSymbol(SyntaxKind.NamespaceKeyword)]
    public sealed class CSharpNamespaceKeyword : CSharpKeywordToken {
        public CSharpNamespaceKeyword() { }
        internal CSharpNamespaceKeyword(SyntaxToken token) : base(token) { }
        internal CSharpNamespaceKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.UsingKeyword)]
    public sealed class CSharpUsingKeyword : CSharpKeywordToken {
        public CSharpUsingKeyword() { }
        internal CSharpUsingKeyword(SyntaxToken token) : base(token) { }
        internal CSharpUsingKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // type of types
    [CSharpSymbol(SyntaxKind.ClassKeyword)]
    public sealed class CSharpClassKeyword : CSharpKeywordToken {
        public CSharpClassKeyword() { }
        internal CSharpClassKeyword(SyntaxToken token) : base(token) { }
        internal CSharpClassKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.StructKeyword)]
    public sealed class CSharpStructKeyword : CSharpKeywordToken {
        public CSharpStructKeyword() { }
        internal CSharpStructKeyword(SyntaxToken token) : base(token) { }
        internal CSharpStructKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.InterfaceKeyword)]
    public sealed class CSharpInterfaceKeyword : CSharpKeywordToken {
        public CSharpInterfaceKeyword() { }
        internal CSharpInterfaceKeyword(SyntaxToken token) : base(token) { }
        internal CSharpInterfaceKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.EnumKeyword)]
    public sealed class CSharpEnumKeyword : CSharpKeywordToken {
        public CSharpEnumKeyword() { }
        internal CSharpEnumKeyword(SyntaxToken token) : base(token) { }
        internal CSharpEnumKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.DelegateKeyword)]
    public sealed class CSharpDelegateKeyword : CSharpKeywordToken {
        public CSharpDelegateKeyword() { }
        internal CSharpDelegateKeyword(SyntaxToken token) : base(token) { }
        internal CSharpDelegateKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // custom operators
    [CSharpSymbol(SyntaxKind.OperatorKeyword)]
    public sealed class CSharpOperatorKeyword : CSharpKeywordToken {
        public CSharpOperatorKeyword() { }
        internal CSharpOperatorKeyword(SyntaxToken token) : base(token) { }
        internal CSharpOperatorKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ExplicitKeyword)]
    public sealed class CSharpExplicitKeyword : CSharpKeywordToken {
        public CSharpExplicitKeyword() { }
        internal CSharpExplicitKeyword(SyntaxToken token) : base(token) { }
        internal CSharpExplicitKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ImplicitKeyword)]
    public sealed class CSharpImplicitKeyword : CSharpKeywordToken {
        public CSharpImplicitKeyword() { }
        internal CSharpImplicitKeyword(SyntaxToken token) : base(token) { }
        internal CSharpImplicitKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // attribute targets
    [CSharpSymbol(SyntaxKind.AssemblyKeyword)]
    public sealed class CSharpAssemblyKeyword : CSharpKeywordToken {
        public CSharpAssemblyKeyword() { }
        internal CSharpAssemblyKeyword(SyntaxToken token) : base(token) { }
        internal CSharpAssemblyKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ModuleKeyword)]
    public sealed class CSharpModuleKeyword : CSharpKeywordToken {
        public CSharpModuleKeyword() { }
        internal CSharpModuleKeyword(SyntaxToken token) : base(token) { }
        internal CSharpModuleKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.TypeKeyword)]
    public sealed class CSharpTypeKeyword : CSharpKeywordToken {
        public CSharpTypeKeyword() { }
        internal CSharpTypeKeyword(SyntaxToken token) : base(token) { }
        internal CSharpTypeKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.FieldKeyword)]
    public sealed class CSharpFieldKeyword : CSharpKeywordToken {
        public CSharpFieldKeyword() { }
        internal CSharpFieldKeyword(SyntaxToken token) : base(token) { }
        internal CSharpFieldKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.MethodKeyword)]
    public sealed class CSharpMethodKeyword : CSharpKeywordToken {
        public CSharpMethodKeyword() { }
        internal CSharpMethodKeyword(SyntaxToken token) : base(token) { }
        internal CSharpMethodKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ParamKeyword)]
    public sealed class CSharpParamKeyword : CSharpKeywordToken {
        public CSharpParamKeyword() { }
        internal CSharpParamKeyword(SyntaxToken token) : base(token) { }
        internal CSharpParamKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.PropertyKeyword)]
    public sealed class CSharpPropertyKeyword : CSharpKeywordToken {
        public CSharpPropertyKeyword() { }
        internal CSharpPropertyKeyword(SyntaxToken token) : base(token) { }
        internal CSharpPropertyKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.EventKeyword)]
    public sealed class CSharpEventKeyword : CSharpKeywordToken {
        public CSharpEventKeyword() { }
        internal CSharpEventKeyword(SyntaxToken token) : base(token) { }
        internal CSharpEventKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // accessors
    [CSharpSymbol(SyntaxKind.GetKeyword)]
    public sealed class CSharpGetKeyword : CSharpKeywordToken {
        public CSharpGetKeyword() { }
        internal CSharpGetKeyword(SyntaxToken token) : base(token) { }
        internal CSharpGetKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.SetKeyword)]
    public sealed class CSharpSetKeyword : CSharpKeywordToken {
        public CSharpSetKeyword() { }
        internal CSharpSetKeyword(SyntaxToken token) : base(token) { }
        internal CSharpSetKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.AddKeyword)]
    public sealed class CSharpAddKeyword : CSharpKeywordToken {
        public CSharpAddKeyword() { }
        internal CSharpAddKeyword(SyntaxToken token) : base(token) { }
        internal CSharpAddKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.RemoveKeyword)]
    public sealed class CSharpRemoveKeyword : CSharpKeywordToken {
        public CSharpRemoveKeyword() { }
        internal CSharpRemoveKeyword(SyntaxToken token) : base(token) { }
        internal CSharpRemoveKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.RefValueKeyword)]
    public sealed class CSharpValueKeyword : CSharpKeywordToken {
        public CSharpValueKeyword() { }
        internal CSharpValueKeyword(SyntaxToken token) : base(token) { }
        internal CSharpValueKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // linq
    [CSharpSymbol(SyntaxKind.FromKeyword)]
    public sealed class CSharpFromKeyword : CSharpKeywordToken {
        public CSharpFromKeyword() { }
        internal CSharpFromKeyword(SyntaxToken token) : base(token) { }
        internal CSharpFromKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.WhereKeyword)]
    public sealed class CSharpWhereKeyword : CSharpKeywordToken {
        public CSharpWhereKeyword() { }
        internal CSharpWhereKeyword(SyntaxToken token) : base(token) { }
        internal CSharpWhereKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.GroupKeyword)]
    public sealed class CSharpGroupKeyword : CSharpKeywordToken {
        public CSharpGroupKeyword() { }
        internal CSharpGroupKeyword(SyntaxToken token) : base(token) { }
        internal CSharpGroupKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.JoinKeyword)]
    public sealed class CSharpJoinKeyword : CSharpKeywordToken {
        public CSharpJoinKeyword() { }
        internal CSharpJoinKeyword(SyntaxToken token) : base(token) { }
        internal CSharpJoinKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.IntoKeyword)]
    public sealed class CSharpIntoKeyword : CSharpKeywordToken {
        public CSharpIntoKeyword() { }
        internal CSharpIntoKeyword(SyntaxToken token) : base(token) { }
        internal CSharpIntoKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.LetKeyword)]
    public sealed class CSharpLetKeyword : CSharpKeywordToken {
        public CSharpLetKeyword() { }
        internal CSharpLetKeyword(SyntaxToken token) : base(token) { }
        internal CSharpLetKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ByKeyword)]
    public sealed class CSharpByKeyword : CSharpKeywordToken {
        public CSharpByKeyword() { }
        internal CSharpByKeyword(SyntaxToken token) : base(token) { }
        internal CSharpByKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.SelectKeyword)]
    public sealed class CSharpSelectKeyword : CSharpKeywordToken {
        public CSharpSelectKeyword() { }
        internal CSharpSelectKeyword(SyntaxToken token) : base(token) { }
        internal CSharpSelectKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.OrderByKeyword)]
    public sealed class CSharpOrderByKeyword : CSharpKeywordToken {
        public CSharpOrderByKeyword() { }
        internal CSharpOrderByKeyword(SyntaxToken token) : base(token) { }
        internal CSharpOrderByKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.OnKeyword)]
    public sealed class CSharpOnKeyword : CSharpKeywordToken {
        public CSharpOnKeyword() { }
        internal CSharpOnKeyword(SyntaxToken token) : base(token) { }
        internal CSharpOnKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.EqualsKeyword)]
    public sealed class CSharpEqualsKeyword : CSharpKeywordToken {
        public CSharpEqualsKeyword() { }
        internal CSharpEqualsKeyword(SyntaxToken token) : base(token) { }
        internal CSharpEqualsKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.AscendingKeyword)]
    public sealed class CSharpAscendingKeyword : CSharpKeywordToken {
        public CSharpAscendingKeyword() { }
        internal CSharpAscendingKeyword(SyntaxToken token) : base(token) { }
        internal CSharpAscendingKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.DescendingKeyword)]
    public sealed class CSharpDescendingKeyword : CSharpKeywordToken {
        public CSharpDescendingKeyword() { }
        internal CSharpDescendingKeyword(SyntaxToken token) : base(token) { }
        internal CSharpDescendingKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // pre-processor
    [CSharpSymbol(SyntaxKind.ElifKeyword)]
    public sealed class CSharpElifKeyword : CSharpKeywordToken {
        public CSharpElifKeyword() { }
        internal CSharpElifKeyword(SyntaxToken token) : base(token) { }
        internal CSharpElifKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.EndIfKeyword)]
    public sealed class CSharpEndIfKeyword : CSharpKeywordToken {
        public CSharpEndIfKeyword() { }
        internal CSharpEndIfKeyword(SyntaxToken token) : base(token) { }
        internal CSharpEndIfKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.RegionKeyword)]
    public sealed class CSharpRegionKeyword : CSharpKeywordToken {
        public CSharpRegionKeyword() { }
        internal CSharpRegionKeyword(SyntaxToken token) : base(token) { }
        internal CSharpRegionKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.EndRegionKeyword)]
    public sealed class CSharpEndRegionKeyword : CSharpKeywordToken {
        public CSharpEndRegionKeyword() { }
        internal CSharpEndRegionKeyword(SyntaxToken token) : base(token) { }
        internal CSharpEndRegionKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.DefineKeyword)]
    public sealed class CSharpDefineKeyword : CSharpKeywordToken {
        public CSharpDefineKeyword() { }
        internal CSharpDefineKeyword(SyntaxToken token) : base(token) { }
        internal CSharpDefineKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.UndefKeyword)]
    public sealed class CSharpUndefKeyword : CSharpKeywordToken {
        public CSharpUndefKeyword() { }
        internal CSharpUndefKeyword(SyntaxToken token) : base(token) { }
        internal CSharpUndefKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.WarningKeyword)]
    public sealed class CSharpWarningKeyword : CSharpKeywordToken {
        public CSharpWarningKeyword() { }
        internal CSharpWarningKeyword(SyntaxToken token) : base(token) { }
        internal CSharpWarningKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ErrorKeyword)]
    public sealed class CSharpErrorKeyword : CSharpKeywordToken {
        public CSharpErrorKeyword() { }
        internal CSharpErrorKeyword(SyntaxToken token) : base(token) { }
        internal CSharpErrorKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.LineKeyword)]
    public sealed class CSharpLineKeyword : CSharpKeywordToken {
        public CSharpLineKeyword() { }
        internal CSharpLineKeyword(SyntaxToken token) : base(token) { }
        internal CSharpLineKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.PragmaKeyword)]
    public sealed class CSharpPragmaKeyword : CSharpKeywordToken {
        public CSharpPragmaKeyword() { }
        internal CSharpPragmaKeyword(SyntaxToken token) : base(token) { }
        internal CSharpPragmaKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.HiddenKeyword)]
    public sealed class CSharpHiddenKeyword : CSharpKeywordToken {
        public CSharpHiddenKeyword() { }
        internal CSharpHiddenKeyword(SyntaxToken token) : base(token) { }
        internal CSharpHiddenKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ChecksumKeyword)]
    public sealed class CSharpChecksumKeyword : CSharpKeywordToken {
        public CSharpChecksumKeyword() { }
        internal CSharpChecksumKeyword(SyntaxToken token) : base(token) { }
        internal CSharpChecksumKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.DisableKeyword)]
    public sealed class CSharpDisableKeyword : CSharpKeywordToken {
        public CSharpDisableKeyword() { }
        internal CSharpDisableKeyword(SyntaxToken token) : base(token) { }
        internal CSharpDisableKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.RestoreKeyword)]
    public sealed class CSharpRestoreKeyword : CSharpKeywordToken {
        public CSharpRestoreKeyword() { }
        internal CSharpRestoreKeyword(SyntaxToken token) : base(token) { }
        internal CSharpRestoreKeyword(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    #endregion

    #region Punctuation
    // arithmetic
    [CSharpSymbol(SyntaxKind.MinusToken)]
    public sealed class CSharpMinusToken : CSharpPunctuationToken {
        public CSharpMinusToken() { }
        internal CSharpMinusToken(SyntaxToken token) : base(token) { }
        internal CSharpMinusToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.PlusToken)]
    public sealed class CSharpPlusToken : CSharpPunctuationToken {
        public CSharpPlusToken() { }
        internal CSharpPlusToken(SyntaxToken token) : base(token) { }
        internal CSharpPlusToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.PercentToken)]
    public sealed class CSharpPercentToken : CSharpPunctuationToken {
        public CSharpPercentToken() { }
        internal CSharpPercentToken(SyntaxToken token) : base(token) { }
        internal CSharpPercentToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.AsteriskToken)]
    public sealed class CSharpAsteriskToken : CSharpPunctuationToken {
        public CSharpAsteriskToken() { }
        internal CSharpAsteriskToken(SyntaxToken token) : base(token) { }
        internal CSharpAsteriskToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.SlashToken)]
    public sealed class CSharpSlashToken : CSharpPunctuationToken {
        public CSharpSlashToken() { }
        internal CSharpSlashToken(SyntaxToken token) : base(token) { }
        internal CSharpSlashToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // assignment
    [CSharpSymbol(SyntaxKind.EqualsToken)]
    public sealed class CSharpEqualsToken : CSharpPunctuationToken {
        public CSharpEqualsToken() { }
        internal CSharpEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.AmpersandEqualsToken)]
    public sealed class CSharpAmpersandEqualsToken : CSharpPunctuationToken {
        public CSharpAmpersandEqualsToken() { }
        internal CSharpAmpersandEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpAmpersandEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.PlusEqualsToken)]
    public sealed class CSharpPlusEqualsToken : CSharpPunctuationToken {
        public CSharpPlusEqualsToken() { }
        internal CSharpPlusEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpPlusEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.MinusEqualsToken)]
    public sealed class CSharpMinusEqualsToken : CSharpPunctuationToken {
        public CSharpMinusEqualsToken() { }
        internal CSharpMinusEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpMinusEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.CaretEqualsToken)]
    public sealed class CSharpCaretEqualsToken : CSharpPunctuationToken {
        public CSharpCaretEqualsToken() { }
        internal CSharpCaretEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpCaretEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.PercentEqualsToken)]
    public sealed class CSharpPercentEqualsToken : CSharpPunctuationToken {
        public CSharpPercentEqualsToken() { }
        internal CSharpPercentEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpPercentEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.SlashEqualsToken)]
    public sealed class CSharpSlashEqualsToken : CSharpPunctuationToken {
        public CSharpSlashEqualsToken() { }
        internal CSharpSlashEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpSlashEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.AsteriskEqualsToken)]
    public sealed class CSharpAsteriskEqualsToken : CSharpPunctuationToken {
        public CSharpAsteriskEqualsToken() { }
        internal CSharpAsteriskEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpAsteriskEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.BarEqualsToken)]
    public sealed class CSharpBarEqualsToken : CSharpPunctuationToken {
        public CSharpBarEqualsToken() { }
        internal CSharpBarEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpBarEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.GreaterThanGreaterThanEqualsToken)]
    public sealed class CSharpGreaterThanGreaterThanEqualsToken : CSharpPunctuationToken {
        public CSharpGreaterThanGreaterThanEqualsToken() { }
        internal CSharpGreaterThanGreaterThanEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpGreaterThanGreaterThanEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.LessThanLessThanEqualsToken)]
    public sealed class CSharpLessThanLessThanEqualsToken : CSharpPunctuationToken {
        public CSharpLessThanLessThanEqualsToken() { }
        internal CSharpLessThanLessThanEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpLessThanLessThanEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ExclamationEqualsToken)]
    public sealed class CSharpExclamationEqualsToken : CSharpPunctuationToken {
        public CSharpExclamationEqualsToken() { }
        internal CSharpExclamationEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpExclamationEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // logical
    [CSharpSymbol(SyntaxKind.BarBarToken)]
    public sealed class CSharpBarBarToken : CSharpPunctuationToken {
        public CSharpBarBarToken() { }
        internal CSharpBarBarToken(SyntaxToken token) : base(token) { }
        internal CSharpBarBarToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.AmpersandAmpersandToken)]
    public sealed class CSharpAmpersandAmpersandToken : CSharpPunctuationToken {
        public CSharpAmpersandAmpersandToken() { }
        internal CSharpAmpersandAmpersandToken(SyntaxToken token) : base(token) { }
        internal CSharpAmpersandAmpersandToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // testing
    [CSharpSymbol(SyntaxKind.EqualsEqualsToken)]
    public sealed class CSharpEqualsEqualsToken : CSharpPunctuationToken {
        public CSharpEqualsEqualsToken() { }
        internal CSharpEqualsEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpEqualsEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.LessThanToken)]
    public sealed class CSharpLessThanToken : CSharpPunctuationToken {
        public CSharpLessThanToken() { }
        internal CSharpLessThanToken(SyntaxToken token) : base(token) { }
        internal CSharpLessThanToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.GreaterThanToken)]
    public sealed class CSharpGreaterThanToken : CSharpPunctuationToken {
        public CSharpGreaterThanToken() { }
        internal CSharpGreaterThanToken(SyntaxToken token) : base(token) { }
        internal CSharpGreaterThanToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.LessThanEqualsToken)]
    public sealed class CSharpLessThanEqualsToken : CSharpPunctuationToken {
        public CSharpLessThanEqualsToken() { }
        internal CSharpLessThanEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpLessThanEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.GreaterThanEqualsToken)]
    public sealed class CSharpGreaterThanEqualsToken : CSharpPunctuationToken {
        public CSharpGreaterThanEqualsToken() { }
        internal CSharpGreaterThanEqualsToken(SyntaxToken token) : base(token) { }
        internal CSharpGreaterThanEqualsToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.QuestionQuestionToken)]
    public sealed class CSharpQuestionQuestionToken : CSharpPunctuationToken {
        public CSharpQuestionQuestionToken() { }
        internal CSharpQuestionQuestionToken(SyntaxToken token) : base(token) { }
        internal CSharpQuestionQuestionToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // bit manipulation
    [CSharpSymbol(SyntaxKind.TildeToken)]
    public sealed class CSharpTildeToken : CSharpPunctuationToken {
        public CSharpTildeToken() { }
        internal CSharpTildeToken(SyntaxToken token) : base(token) { }
        internal CSharpTildeToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ExclamationToken)]
    public sealed class CSharpExclamationToken : CSharpPunctuationToken {
        public CSharpExclamationToken() { }
        internal CSharpExclamationToken(SyntaxToken token) : base(token) { }
        internal CSharpExclamationToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.CaretToken)]
    public sealed class CSharpCaretToken : CSharpPunctuationToken {
        public CSharpCaretToken() { }
        internal CSharpCaretToken(SyntaxToken token) : base(token) { }
        internal CSharpCaretToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.AmpersandToken)]
    public sealed class CSharpAmpersandToken : CSharpPunctuationToken {
        public CSharpAmpersandToken() { }
        internal CSharpAmpersandToken(SyntaxToken token) : base(token) { }
        internal CSharpAmpersandToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.BarToken)]
    public sealed class CSharpBarToken : CSharpPunctuationToken {
        public CSharpBarToken() { }
        internal CSharpBarToken(SyntaxToken token) : base(token) { }
        internal CSharpBarToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.GreaterThanGreaterThanToken)]
    public sealed class CSharpGreaterThanGreaterThanToken : CSharpPunctuationToken {
        public CSharpGreaterThanGreaterThanToken() { }
        internal CSharpGreaterThanGreaterThanToken(SyntaxToken token) : base(token) { }
        internal CSharpGreaterThanGreaterThanToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.LessThanLessThanToken)]
    public sealed class CSharpLessThanLessThanToken : CSharpPunctuationToken {
        public CSharpLessThanLessThanToken() { }
        internal CSharpLessThanLessThanToken(SyntaxToken token) : base(token) { }
        internal CSharpLessThanLessThanToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // single tokens
    [CSharpSymbol(SyntaxKind.DollarToken)]
    public sealed class CSharpDollarToken : CSharpPunctuationToken {
        public CSharpDollarToken() { }
        internal CSharpDollarToken(SyntaxToken token) : base(token) { }
        internal CSharpDollarToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.BackslashToken)]
    public sealed class CSharpBackslashToken : CSharpPunctuationToken {
        public CSharpBackslashToken() { }
        internal CSharpBackslashToken(SyntaxToken token) : base(token) { }
        internal CSharpBackslashToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.ColonToken)]
    public sealed class CSharpColonToken : CSharpPunctuationToken {
        public CSharpColonToken() { }
        internal CSharpColonToken(SyntaxToken token) : base(token) { }
        internal CSharpColonToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.SemicolonToken)]
    public sealed class CSharpSemicolonToken : CSharpPunctuationToken {
        public CSharpSemicolonToken() { }
        internal CSharpSemicolonToken(SyntaxToken token) : base(token) { }
        internal CSharpSemicolonToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.DoubleQuoteToken)]
    public sealed class CSharpDoubleQuoteToken : CSharpPunctuationToken {
        public CSharpDoubleQuoteToken() { }
        internal CSharpDoubleQuoteToken(SyntaxToken token) : base(token) { }
        internal CSharpDoubleQuoteToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.SingleQuoteToken)]
    public sealed class CSharpSingleQuoteToken : CSharpPunctuationToken {
        public CSharpSingleQuoteToken() { }
        internal CSharpSingleQuoteToken(SyntaxToken token) : base(token) { }
        internal CSharpSingleQuoteToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.CommaToken)]
    public sealed class CSharpCommaToken : CSharpPunctuationToken {
        public CSharpCommaToken() { }
        internal CSharpCommaToken(SyntaxToken token) : base(token) { }
        internal CSharpCommaToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.DotToken)]
    public sealed class CSharpDotToken : CSharpPunctuationToken {
        public CSharpDotToken() { }
        internal CSharpDotToken(SyntaxToken token) : base(token) { }
        internal CSharpDotToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.QuestionToken)]
    public sealed class CSharpQuestionToken : CSharpPunctuationToken {
        public CSharpQuestionToken() { }
        internal CSharpQuestionToken(SyntaxToken token) : base(token) { }
        internal CSharpQuestionToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.HashToken)]
    public sealed class CSharpHashToken : CSharpPunctuationToken {
        public CSharpHashToken() { }
        internal CSharpHashToken(SyntaxToken token) : base(token) { }
        internal CSharpHashToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // groupings
    [CSharpSymbol(SyntaxKind.OpenParenToken)]
    public sealed class CSharpOpenParenToken : CSharpPunctuationToken {
        public CSharpOpenParenToken() { }
        internal CSharpOpenParenToken(SyntaxToken token) : base(token) { }
        internal CSharpOpenParenToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.CloseParenToken)]
    public sealed class CSharpCloseParenToken : CSharpPunctuationToken {
        public CSharpCloseParenToken() { }
        internal CSharpCloseParenToken(SyntaxToken token) : base(token) { }
        internal CSharpCloseParenToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.OpenBraceToken)]
    public sealed class CSharpOpenBraceToken : CSharpPunctuationToken {
        public CSharpOpenBraceToken() { }
        internal CSharpOpenBraceToken(SyntaxToken token) : base(token) { }
        internal CSharpOpenBraceToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.CloseBraceToken)]
    public sealed class CSharpCloseBraceToken : CSharpPunctuationToken {
        public CSharpCloseBraceToken() { }
        internal CSharpCloseBraceToken(SyntaxToken token) : base(token) { }
        internal CSharpCloseBraceToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.OpenBracketToken)]
    public sealed class CSharpOpenBracketToken : CSharpPunctuationToken {
        public CSharpOpenBracketToken() { }
        internal CSharpOpenBracketToken(SyntaxToken token) : base(token) { }
        internal CSharpOpenBracketToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.CloseBracketToken)]
    public sealed class CSharpCloseBracketToken : CSharpPunctuationToken {
        public CSharpCloseBracketToken() { }
        internal CSharpCloseBracketToken(SyntaxToken token) : base(token) { }
        internal CSharpCloseBracketToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // pointers
    [CSharpSymbol(SyntaxKind.SlashGreaterThanToken)]
    public sealed class CSharpSlashGreaterThanToken : CSharpPunctuationToken {
        public CSharpSlashGreaterThanToken() { }
        internal CSharpSlashGreaterThanToken(SyntaxToken token) : base(token) { }
        internal CSharpSlashGreaterThanToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.LessThanSlashToken)]
    public sealed class CSharpLessThanSlashToken : CSharpPunctuationToken {
        public CSharpLessThanSlashToken() { }
        internal CSharpLessThanSlashToken(SyntaxToken token) : base(token) { }
        internal CSharpLessThanSlashToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // inc/dec
    [CSharpSymbol(SyntaxKind.MinusMinusToken)]
    public sealed class CSharpMinusMinusToken : CSharpPunctuationToken {
        public CSharpMinusMinusToken() { }
        internal CSharpMinusMinusToken(SyntaxToken token) : base(token) { }
        internal CSharpMinusMinusToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    [CSharpSymbol(SyntaxKind.PlusPlusToken)]
    public sealed class CSharpPlusPlusToken : CSharpPunctuationToken {
        public CSharpPlusPlusToken() { }
        internal CSharpPlusPlusToken(SyntaxToken token) : base(token) { }
        internal CSharpPlusPlusToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // scope
    [CSharpSymbol(SyntaxKind.ColonColonToken)]
    public sealed class CSharpColonColonToken : CSharpPunctuationToken {
        public CSharpColonColonToken() { }
        internal CSharpColonColonToken(SyntaxToken token) : base(token) { }
        internal CSharpColonColonToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // pointer
    [CSharpSymbol(SyntaxKind.MinusGreaterThanToken)]
    public sealed class CSharpMinusGreaterThanToken : CSharpPunctuationToken {
        public CSharpMinusGreaterThanToken() { }
        internal CSharpMinusGreaterThanToken(SyntaxToken token) : base(token) { }
        internal CSharpMinusGreaterThanToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }

    // lambda
    [CSharpSymbol(SyntaxKind.EqualsGreaterThanToken)]
    public sealed class CSharpEqualsGreaterThanToken : CSharpPunctuationToken {
        public CSharpEqualsGreaterThanToken() { }
        internal CSharpEqualsGreaterThanToken(SyntaxToken token) : base(token) { }
        internal CSharpEqualsGreaterThanToken(SyntaxToken token, CSharpObject parent, CSharpSemanticModel semanticModel) : base(token, parent, semanticModel) { }
    }
    #endregion
}
